/* 
 *  PDA project -- UBS/IUT de Vannes -- Dept Informatique
 *
 *  $Id$
 *
 *  Copyright 2007-08 © IUT de Vannes
 *  Ce logiciel pédagogique est diffusé sous licence GPL
 */
package pda.ancien;

import pda.ancien.AncienModel;
import javax.swing.*;
import javax.swing.border.EtchedBorder;
import javax.swing.border.TitledBorder;
import javax.swing.filechooser.FileFilter;
import javax.swing.filechooser.FileNameExtensionFilter;

import java.util.regex.*;

import java.awt.*;
import java.io.*;
import java.util.*;


/**
 * <h1>Classe AncienView - Fait office de View dans le modele MVC</h1>
 * Cette classe est la plus conséquente de toutes. Elle construit l'interface graphique.
 * Elle utilise toutes les autre classes de l'ancien et les met en forme pour rendre l'application fonctionnelle pour un utilisateur.
 * Elle utilise : 
 * <ul><li>AncienModel pour récuperer les activites presente dans l'arrayList du model</li>
 * <li>Activite et ses classes heritees pour ajouter different types d'activites au model</li>
 * <li>AncienController pour gérer les evenement</li></ul>
 * @author Mathieu Cornic
 * @author Camille Guerin
 * A rendre Jeudi 19 juin 2008
 */
public class AncienView {

    protected AncienModel model;//model de l'ancien
    protected JPanel panelGlobal = new JPanel ();//le panel global de l'ancien (permet de faire le lien avec l'application)
    protected JButton options, nouvelleActivite;//les boutons utilises dans le listener en plus de cette classe
    protected JPopupMenu popUpMenu, popUpMenuActivite;//les popUp utilises dans le listener en plus de cette classe
    
    private JPanel panelHaut, panelCentre, panelBas, panelJourBas, panelJourHaut, panelCentreActivite,  panelJourCentreSup;//les panels qui sont utilises dans plusieurs methodes
    private Ancien listener;//le listener
    private String[] listeMois;//la liste des mois de l'annee
    private JButton anneeSuivante, anneePrecedente, retour, retourActivite, jourPrecedentBouton, jourSuivantBouton, enregistrerActivite;    
    private JButton[] jours;//un tableau de boutons (pour les jours du calendrier)
    private JLabel[] sems;//un tableau de labels (pour les semaines du calendrier)
    private JComboBox moisBox;//la comboBox des mois utilisee dans plusieurs methodes
    private JLabel annee, jour, typeActivite;//Jlabels utilises dans plusieurs methodes
    private GregorianCalendar calendrier;//calendrier de l'application
    private int premierJourSemaine, premiereSemaine, nbJoursMois, moisCourant, anneeCourante, idCourant, jourCourant, id;//entier utilises dans plusieurs methodes (correspond souvent aux parametre d'une activite)
    private JEditorPane motifText;//la zone d'edition du motif (utilisee dans plusieurs methodes)
    private JTextField dateJourText, dateMoisText, dateAnneeText, heureDebutH, heureDebutM, heureFinH, heureFinM, lieuText, initiateurText, matiereText, professeurText, listePersonneText;//les jtextfield utilises dans plusieurs methodes
    private JFileChooser chooser; //utilise pour creer le dialogue de gestion des fichiers
    private File selectedFile; //utilise pour conserver le fichier edite
    private boolean estPasseParMenuPopUpActivite = false;
    
    /**
     * Le constructeur de l'interface de l'ancien
     * @param aController le controller de l'ancien
     * @param aModel le model de l'ancien
     */
    public AncienView (Ancien aController, AncienModel aModel) {
        model = aModel;
        listener = aController;
              
    } // ------------------------------------------------------------- AncienView ()

    
    //======================= Initialisation de l'ecran principal avec son calendrier ======================//
    
    /**
     * Methode qui permet d'initialiser le panel global qui sera utilisé par le launcher.
     * A l'intérieur on initialise consécutivement les différentes partie de l'écran (le haut, le centre et le bas).
     * On a factorisé ces parties pour éviter d'alourdir la  methode principale.
     */
    public void initPanel () {

    	
    	jourCourant = 0;//Lorsqu'on est sur le calendrier, il n'y a pas de jour par defaut donc on le met à 0
    	
    	panelGlobal.removeAll ();
    	this.restaure ();
	// On initialise le calendrier
	calendrier = new GregorianCalendar ();
	calendrier = (GregorianCalendar) Calendar.getInstance ();
		
	// Initialise le mois et l'annee courants
	moisCourant = calendrier.get (Calendar.MONTH);
	anneeCourante = calendrier.get (Calendar.YEAR);
    	
    	//Initialisation des propriétés du panel global
    	panelGlobal.setLayout (new BorderLayout ());
    	panelGlobal.setBackground (Color.WHITE);
    	
    	//On inititialise CalendrierHaut et on l'ajoute au panel global
    	this.initCalendrierHaut ();
    	panelGlobal.add (panelHaut, BorderLayout.NORTH);
    	
    	//On inititialise CalendrierCentre et on l'ajoute au panel global
    	this.initCalendrierCentre ();
    	panelGlobal.add (panelCentre, BorderLayout.CENTER);
    	
    	//On inititialise CalendrierBas et on l'ajoute au panel global
    	this.initCalendrierBas ();
    	panelGlobal.add (panelBas, BorderLayout.SOUTH);
    	
    	//On affiche le mois courant et l'annee courante selon la date du jour
    	this.afficheMoisCourant (moisCourant, anneeCourante);
    	
    	panelGlobal.repaint ();
    	
    } // ---------------------------------------------------------- initPanel ()
    
    /**
     * Methode qui permet le meme travail que initPanel sauf que le calendrier n'est pas reinitialise
     * a la date du jour
     */
    public void initNouveauCalendrier () {
    	jourCourant = 0;
    	
    	panelGlobal.removeAll ();
    	this.restaure ();
    	
    	//Initialisation des propriétés du panel global
    	panelGlobal.setLayout (new BorderLayout ());
    	panelGlobal.setBackground (Color.WHITE);
    	
    	//On inititialise CalendrierHaut et on l'ajoute au panel global
    	this.initCalendrierHaut ();
    	panelGlobal.add (panelHaut, BorderLayout.NORTH);
    	
    	//On inititialise CalendrierCentre et on l'ajoute au panel global
    	this.initCalendrierCentre ();
    	panelGlobal.add (panelCentre, BorderLayout.CENTER);
    	
    	//On inititialise CalendrierBas et on l'ajoute au panel global
    	this.initCalendrierBas ();
    	panelGlobal.add (panelBas, BorderLayout.SOUTH);
    	
    	//On affiche le mois courant et l'annee courante selon la date du jour
    	this.afficheMoisCourant (moisCourant, anneeCourante);
    	
    	panelGlobal.repaint ();
    }// ---------------------------------------------------------- initNouveauCalendrierHaut ()
    
    /**
     * Methode qui permet d'initialiser la partie haute du calendrier,
     * c'est a dire la combobox avec la liste des mois ainsi que l'annee et ses deux boutons de mouvement
     * Elle sera appelée dans la méthode initPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans le constructeur de AncienView
     */
    private void initCalendrierHaut () {
    	
    	//On récupère une image
    	Toolkit toolkit = Toolkit.getDefaultToolkit ();
    	Image barrePDA = toolkit.getImage ("data/img/ancien/barreGrise.png");
    	
    	//on initialise le panelHaut avec ses propriétés
    	panelHaut = new ImagePanel (barrePDA);
    	panelHaut.setLayout (new BorderLayout ());
    	panelHaut.setPreferredSize (new Dimension (0, 50));
    	
    	
    	//###################  Panel du mois  #################
    	
    	//on initialise le panel du mois avec ses propriétés
    	JPanel panelMois = new JPanel ();
    	panelMois.setOpaque (false);
    	panelMois.setLayout (new BorderLayout ());
    	panelMois.setPreferredSize (new Dimension (130, 0));
    	
    	//On initialise la liste de mois et on l'ajoute à une JComboBox (on y définit ses propriétés)
    	initListeMois ();
    	moisBox = new JComboBox (listeMois);
    	moisBox.setMaximumRowCount (6);//On définit la taille de la liste déroulante à 6 éléments affichés
    	moisBox.setOpaque (false);
    	moisBox.setSelectedIndex (moisCourant);
    	moisBox.setFont (new Font ("Arial", Font.BOLD ,12));
    	
	moisBox.setActionCommand ("DateChangee"); // Si on change la date, cela genere un evenement
	moisBox.addActionListener (listener); // L'evenement sera capte par le listener
    	
    	//on ajoute le panelMois
    	panelMois.add (moisBox, BorderLayout.CENTER);
    	
    	
    	
    	//###################  Panel de l'annee  ##############
    	//on initialise le panel de l'année et ses propriétés
    	JPanel panelAnnee = new JPanel ();
    	panelAnnee.setOpaque (false);
    	panelAnnee.setLayout (new BorderLayout ());
    	panelAnnee.setPreferredSize (new Dimension (150, 0));
    	
    	//On créé un nouveau bouton auquel on va ajouter un icone qui représentera une flèche pour "Precedent"
    	ImageIcon flecheG = new ImageIcon ("data/img/ancien/flecheGB.png");
    	anneePrecedente = new JButton (flecheG);
    	anneePrecedente.setRolloverIcon (new ImageIcon ("data/img/ancien/flecheGBRollOver2.png"));
    	anneePrecedente.setPressedIcon (new ImageIcon ("data/img/ancien/flecheGBRollOver.png"));
    	anneePrecedente.setContentAreaFilled (false);
    	anneePrecedente.setToolTipText ("Annee precedente");
    	anneePrecedente.addActionListener (listener);
    	anneePrecedente.setActionCommand ("Annee Precedente");
    	
    	//On créé un label avec l'année et ses propriétés
    	annee = new JLabel (Integer.toString (anneeCourante), JLabel.CENTER);
    	annee.setOpaque (false);
    	annee.setFont (new Font ("Arial", Font.BOLD, 15));
    	annee.setForeground (Color.white);
    	
    	//On créé un bouton auquel on va ajouter un icone qui représentera une flèche pour "Suivant"
    	ImageIcon flecheD = new ImageIcon ("data/img/ancien/flecheDB.png");
    	anneeSuivante = new JButton (flecheD);
    	anneeSuivante.setRolloverIcon (new ImageIcon ("data/img/ancien/flecheDBRollOver2.png"));
    	anneeSuivante.setPressedIcon (new ImageIcon ("data/img/ancien/flecheDBRollOver.png"));
    	anneeSuivante.setContentAreaFilled (false);
    	anneeSuivante.setToolTipText ("Annee suivante");
    	anneeSuivante.addActionListener (listener);
    	anneeSuivante.setActionCommand ("Annee Suivante");
    	
    	
    	//##################  Ajouts consécutifs ##################
    	
    	//On ajoute le bouton précédent et suivant et le label de l'année
    	panelAnnee.add (anneePrecedente, BorderLayout.WEST);
    	panelAnnee.add (annee, BorderLayout.CENTER);
    	panelAnnee.add (anneeSuivante, BorderLayout.EAST);
    	
    	//Ajout le panel du mois et le panel de l'année dans le panel haut
    	panelHaut.add (panelMois, BorderLayout.WEST);
    	panelHaut.add (panelAnnee, BorderLayout.EAST);
    	
    }// ----------------------------------------------------------- initCalendrierHaut ()
    
    /**
     * Methode qui permet d'initialiser la partie centre du calendrier,
     * c'est a dire le calendrier en lui même avec les panels représentant les noms des jours,
     * les jours représentés par des boutons et enfin les semaines correspondantes
     * Elle sera appelée dans la méthode initPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans le constructeur de AncienView
     */
    private void initCalendrierCentre () {
    	
    	//On initialise le panel Centre et ses propriétés
    	panelCentre = new JPanel ();
    	panelCentre.setLayout (new GridLayout (7, 8));//On met le layout en Grid pour le calendrier
    	panelCentre.setBackground (Color.white);
    	
    	//################  Barre des noms de jours  ################
    	
    	//On créé les label et panel des noms de jours en tant que tableau (pour pouvoir les initialiser avec une boucle)
    	JLabel[] joursSemaineLabel = new JLabel[8];
    	JPanel[] joursSemainePanel = new ImagePanel[8];
    	
    	//On récupère l'image que l'on mettra en fond des panels des noms des jours
    	java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit ();
    	Image degradeOrange = toolkit.getImage ("data/img/ancien/degradeOrange.png");

    	//tant qu'on est sur la première ligne, on initialise les panels et labels et affecte les propriétés
    	for (int i = 0; i<8; i++) {
	    joursSemaineLabel[i] = new JLabel ("", JLabel.CENTER);
	    joursSemainePanel[i] = new ImagePanel (degradeOrange);
	    joursSemaineLabel[i].setFont (new Font ("Arial", Font.BOLD ,18));//change la police et la taille de la police
	    joursSemaineLabel[i].setForeground (Color.white);//change la couleur de la police
	    joursSemainePanel[i].add (joursSemaineLabel[i]);//on ajoute le label au panel
	    panelCentre.add (joursSemainePanel[i], JPanel.CENTER_ALIGNMENT);//on ajoute le panel au panel Centre
    	}
    	
    	//on initialise les différentes case pour nommer les jours (lundi, mardi, etc.)
    	joursSemaineLabel[0].setText ("S");
    	joursSemainePanel[0].setBorder (BorderFactory.createLineBorder (Color.gray));//cas spécial pour "semaine", on entoure en gris
    	joursSemaineLabel[1].setText ("L");
    	joursSemaineLabel[2].setText ("M");
    	joursSemaineLabel[3].setText ("M");
    	joursSemaineLabel[4].setText ("J");
    	joursSemaineLabel[5].setText ("V");
    	joursSemaineLabel[6].setText ("S");
    	joursSemaineLabel[7].setText ("D");

    	
    	//#################  Boutons des jours du calendrier  #################
    	
    	//Création des tableaux de JButton, labels
	int j=0;//variable d'incrément qui permettra de savoir quand ajouter les numéros de semaines
	jours = new JButton[56];
	sems = new JLabel[6];
		
	//tant que que l'on a pas fini de parcourir le tableau de labels, on initialise les labels des semaines et leurs propriétés
	for (int i=0;i<6;i++) {
	    sems[i] = new JLabel ();
	    sems[i].setVerticalAlignment (JLabel.CENTER);
	    sems[i].setHorizontalAlignment (JLabel.CENTER);
	    sems[i].setForeground (new Color (245, 141, 34));
	    sems[i].setFont (new Font ("Arial", Font.BOLD , 12));
	}

	//tant que l'on a pas fini de parcourir le calendrier, on ajoute les boutons
	for (int i = 0; i<42; i++) {
			
	    //Tous les 7 ajouts, on ajoute le numero de la semaine
	    if ( (i%7)==0) {
		panelCentre.add (sems[j]);
		j++;
	    }
	    jours[i] = new JButton ();
	    Insets noMargin = new Insets (0, 0, 0, 0);
	    jours[i].setMargin (noMargin);//permet d'enlever la marge à l'intérieur des boutons
	    panelCentre.add (jours[i]);
			
	}
    }// ----------------------------------------------------------- initCalendrierCentre ()
    
    /**
     * Methode qui permet d'initialiser la partie basse du calendrier,
     * c'est a dire le bouton options avec son menu déroulant et le bouton retour
     * Elle sera appelée dans la méthode initPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans le constructeur de AncienView
     */
    private void initCalendrierBas () {
    	
    	//on initialise le panel bas et ses propriétés
    	panelBas = new JPanel ();
    	panelBas.setLayout (new GridLayout (1, 2));
    	panelBas.setPreferredSize (new Dimension (0, 30));
    	panelBas.setMinimumSize (new Dimension (0, 30));
    	
    	//################ Gestion des boutons options et retour ##################
    	
    	//On initialise le bouton options et ses propriétés
    	options = new JButton ("Options");
    	options.setFont (new Font ("Arial", Font.BOLD , 20));
    	options.addActionListener (listener);
    	options.setActionCommand ("OptionsBase");
    	
    	//On initialise le bouton retour et ses propriétés
    	retour = new JButton ("Retour");
    	retour.setFont (new Font ("Arial", Font.BOLD , 20));
    	retour.setEnabled (false);
    	retour.addActionListener (listener);
    	
    	
    	//#################### Gestion du menu popup du bouton options ###############
    	
    	this.initPopUpMenuOptionsBase ();
		
	//############### Ajout des boutons #################"
		
	//On ajoute les deux boutons au panel du bas
	panelBas.add (options);
    	panelBas.add (retour);
    	
    }// ----------------------------------------------------------- initCalendrierBas ()
    
    /**
     * Methode qui permet d'initialiser les mois dans un tableau de type String
     */
    private void initListeMois () {
		
	listeMois = new String[12];
	listeMois[0] = "Janvier";
	listeMois[1] = "Fevrier";
	listeMois[2] = "Mars";
	listeMois[3] = "Avril";
	listeMois[4] = "Mai";
	listeMois[5] = "Juin";
	listeMois[6] = "Juillet";
	listeMois[7] = "Aout";
	listeMois[8] = "Septembre";
	listeMois[9] = "Octobre";
	listeMois[10] = "Novembre";
	listeMois[11] = "Decembre";
	
    }// ----------------------------------------------------------- initListeMois ()


    /**
     * Permet l'affichage du mois courant dans le calendrier
     * La methode se divise en trois parties :
     * D'abord on recherche la position du premier jour du mois (on cherche la date du premier jour du mois, 
     * puis on calcule l'ecart entre le jour courant et le premier jour du mois et on determine la position du premier jour du mois dans la premiere semaine)
     * Puis on recherche le nombre de jours dans le mois
     * Enfin on affiche le calendrier
     * @param moisCourant le mois a afficher
     * @param anneeCourante l'annee a afficher
     */
    private void afficheMoisCourant (int moisCourant, int anneeCourante) {
			
	// On initialise l'annee et le mois courants
	this.anneeCourante = anneeCourante;
	this.moisCourant = moisCourant;
	annee.setText (Integer.toString (anneeCourante));
			
	//---------------------------------------- Calcul de la position du premier jour du mois dans la semaine ------------------------------------//
			
	// Renvoit un entier : 1 = dimanche, 2 = lundi , ... , 7 = samedi
	calendrier.set (anneeCourante,moisCourant,1);//
	premierJourSemaine = calendrier.get (Calendar.DAY_OF_WEEK);
			
	// On retablit l'ordre : 2 = lundi, ... , 8 = dimanche
	if (premierJourSemaine == 1)
	    premierJourSemaine = 8;
			
	/* Le premier jour de la semaine en angleterre etant le dimanche, on retire 1 a la variable premierJourSemaine pour que le premier jour soit le lundi
	 * De plus, comme on commence la semaine par 1 mais que la boucle commence par 0, on retire 1 a la variable premierJourSemaine
	 */
	premierJourSemaine = premierJourSemaine-2;			
				
	//---------------------------------------- Calcul du nombre de jour du mois ------------------------------------//
			
	// Maintenant qu'on connait la position du premier jour du mois, on va determiner le nombre de jours du mois
	nbJoursMois = this.calculeNbJoursMois (moisCourant, anneeCourante);
			
	//		 On calcule le premier numero de semaine		
	premiereSemaine = calendrier.get (Calendar.WEEK_OF_YEAR);	
	
	// On reinitialise le calendrier pour les prochains calculs
	calendrier = (GregorianCalendar) Calendar.getInstance ();
			
	// On possede toutes les informations necessaires a l'affichage du calendrier
	// Donc on l'affiche
	this.afficheCalendrier (premierJourSemaine, premiereSemaine, nbJoursMois);
	
    }// ----------------------------------------------------------- afficheMoisCourant (moisCourant : int, anneeCourante : int)


    /**
     * Methode calculant le nombre de jours selon un mois et une annee donnee.
     * Il faut prendre en compte le mois de fevrier. Le nombre de jours peut changer selon les annees, c'est pourquoi
     * on prend en compte l'annee
     * @param mois le mois en question
     * @param annee l'annee en quesion
     * @return le nombre de jours du mois en question selon l'annee
     */
    private int calculeNbJoursMois (int mois, int annee) {
		
	int nbJoursMois;
	
	moisCourant = mois;
	anneeCourante = annee;
			
	if (moisCourant == Calendar.FEBRUARY)
	    // Si on veut afficher le mois de fevrier
				
	    // Et si l'annee est bisextile
	    if (calendrier.isLeapYear (anneeCourante))
		nbJoursMois = 29; // Alors le mois est de 29 jours
	    else
		// Sinon
		nbJoursMois = 28; // Le mois est de 28 jours
					
	else if (moisCourant == Calendar.JANUARY
		 // Sinon si on veut afficher un mois de 31 jour
		 || moisCourant == Calendar.MARCH
		 || moisCourant == Calendar.MAY
		 || moisCourant == Calendar.JULY
		 || moisCourant == Calendar.AUGUST
		 || moisCourant == Calendar.OCTOBER
		 || moisCourant == Calendar.DECEMBER)
	    nbJoursMois = 31;
				
	// Sinon les mois sont de 30 jours
	else
	    nbJoursMois = 30;
				
	return nbJoursMois;
		
    }// ----------------------------------------------------------- calculeNbJoursMois (mois : int, annee : int)


    /**
     * Permet l'affichage d'un calendrier en fonction du premier jour de la semaine, la première semaine et le nombre de jours du mois
     * @param premierJourSemaine
     * @param premiereSemaine
     * @param nbJoursMois
     */
    private void afficheCalendrier (int premierJourSemaine, int premiereSemaine, int nbJoursMois) {
		
	this.premierJourSemaine = premierJourSemaine;//le premier jours de la semaine
	this.premiereSemaine = premiereSemaine;//la premiere semaine
	this.nbJoursMois = nbJoursMois;//le nombre de jours du mois
		
	//j le jour a afficher
	int j = 1;
		
	int debut = premierJourSemaine;
		
	//On defini les propriete par defaut des boutons (noir et taille 12)
	for (int k=0;k<42;k++) {
	    jours[k].setForeground (Color.black);
	    jours[k].setFont (new Font ("Sans Serif", Font.PLAIN, 12));
	}
		
	// On remplit les 42 jours
	for (int k=0;k<42;k++) {
			
	    if ( (k >= debut) && (k < (nbJoursMois + debut))) {
		// Si on est entre le debut et la fin du mois
		//On affiche et on permet l'utilisation des boutons des jours
		jours[k].setEnabled (true);
		jours[k].setVisible (true);
				
		// On affiche le jour avec les propriétés d'écriture
		jours[k].setText (Integer.toString (j));
		jours[k].addActionListener (listener);
				
		this.verifierJour (j,debut);//On verifie s'il y a une activite au bouton prevu (avec le decalage)
				
		if ( (anneeCourante == calendrier.get (Calendar.YEAR)) && (moisCourant == calendrier.get (Calendar.MONTH)) && (j == calendrier.get (Calendar.DATE))) {
		    // Si le jour a afficher est le jour courant
		    // On affiche le jour d'aujourd'hui differemment (souligné, gras et en taille plus grande)
		    jours[k].setText ("<html><u>"+jours[k].getText ()+"</u></html>");
		    jours[k].setFont (new Font ("Arial", Font.BOLD, 14));
		    jours[k].setActionCommand (Integer.toString (j));		
					
		}
					
		// On incremente l'indice du jour a afficher
		j++;
				
	    } else {
		// Sinon
		// On affiche un bouton vide et non cliquable
		jours[k].setText ("");
		jours[k].setEnabled (false);
		jours[k].setVisible (false);
	    }
			
	}
		
	// On remplit les numeros des semaines
	for (int i=0;i<6;i++) {
	    sems[i].setText (Integer.toString (premiereSemaine+i));
	    if (premiereSemaine == 52 || premiereSemaine == 53)
		//Si la premiere semaine = 52 ou 53, alors on met la premiere semaine à 0 (eviter que les semaine continuent a 54, 55, 56 etc. dans l'affichage)
		premiereSemaine = 0;
	}
    }// ----------------------------------------------------------- afficheCalendrier (premierJourSemaine : int, premiereSemaine : int, nbJoursMois : int)


    /**
     * Methode qui permet de verifier si une activite existe dans un jour.
     * Et si oui, on colore le bouton correspondant en orange
     * @param j numero du bouton
     * @param debut decalage par rapport au premier jour du mois 
     */
    private void verifierJour (int j,int debut) {
			
	if (model.size ()>0) {
	    //S'il existe au moins une activite
	    int i=0;
				
	    //on parcours l'arrayList des activites
	    while (i < model.size ()) {
		//On créé deux string qui correspondent respectivement à la date courante (avec tous les boutons du mois), et à la date des activites presentes dans l'arrayList
		String s = String.valueOf (j)+ (moisCourant+1)+anneeCourante;
		String date = Integer.toString (model.chercheActivite (i).getJour ())+Integer.toString (model.chercheActivite (i).getMois ())+Integer.toString (model.chercheActivite (i).getAnnee ());
					
		if (date.equals (s)) {
		    //Si ces deux String sont egaux (si les dates correspondent)
						
		    //La police du bouton correspondant à l'activite existante prend une couleur orange
		    jours[j+debut-1].setForeground ( (new Color (245, 141, 34)));
						
		    jours[j+debut-1].setFont (new Font ("Arial", Font.BOLD, 14));
		}
		i ++;//increment de i
	    }
	}
    }// ----------------------------------------------------------- verifierJour (j : int, debut : int)


    /**
     * Methode permettant d'afficher le moisCourant modifié.
     * Elle est appelée lorsque l'on change de date (en changeant d'annee, etc.)
     */
    public void changerDate () {
		
	afficheMoisCourant (moisBox.getSelectedIndex (),anneeCourante);		
	
    }// ----------------------------------------------------------- changerDate ()


    /**
     * Methode qui permet d'initialiser le menu popUp qui apparait 
     * lorsqu'on clique sur le bouton "options" lorsqu'on est sur le calendrier de base
     * Il contient différent menus :
     * <ul>
     * 	<li>Nouvelle activite</li>
     * 		<ul>
     * 			<li>RDV</li>
     * 			<li>Cours</li>
     * 			<li>Reunion</li>
     * 			<li>Autre</li>
     * 		</ul>
     * 	<li>Supprimer toutes activite</li>
     * 	<li>Importer des activites</li>
     * 	<li>Sauvegarder des activite</li>
     * </ul>
     */
    private void initPopUpMenuOptionsBase () {
		
		
	//On initialise le menu popup qui s'affichera pour le bouton options
	popUpMenu = new JPopupMenu ();
		
	//On initialise le menu nouvelle activité et ses sous menus (rdv, cours, etc.)
	JMenu nouvActivite = new JMenu ("Nouvelle activite");
	JMenuItem rdvActivite = new JMenuItem ("RDV");
	rdvActivite.addActionListener (listener);
	JMenuItem coursActivite = new JMenuItem ("Cours");
	coursActivite.addActionListener (listener);
	JMenuItem reunionActivite = new JMenuItem ("Reunion");
	reunionActivite.addActionListener (listener);
	JMenuItem autreActivite = new JMenuItem ("Autre");
	autreActivite.addActionListener (listener);
		
	
	JMenuItem supprimerToutesActivites = new JMenuItem ("Supprimer toutes activites");
		
	if (model.size () == 0) {
	    //Si il n'y a aucune activite
	    //On ne peut pas cliquer sur toutSupprimer
	    supprimerToutesActivites.setEnabled (false);
	}
	supprimerToutesActivites.addActionListener (listener);
		
	//menu "importer des activites"
	JMenuItem importerListe = new JMenuItem ("Importer des activites");
	importerListe.addActionListener (listener);
		
	//menu "sauvegarder des activites"
	JMenuItem sauvegarderListe = new JMenuItem ("Sauvegarder des activites");
	sauvegarderListe.addActionListener (listener);
	
	//On ajoute les sous menu dans le menu nouvelle activite
	nouvActivite.add (rdvActivite);
	nouvActivite.add (coursActivite);
	nouvActivite.add (reunionActivite);
	nouvActivite.add (autreActivite);
		
	//On ajoute les menus dans le popup
	popUpMenu.add (nouvActivite);
	popUpMenu.add (supprimerToutesActivites);
	popUpMenu.add (importerListe);
	popUpMenu.add (sauvegarderListe);
		
		
	estPasseParMenuPopUpActivite = false;
		
    }// ----------------------------------------------------------- initPopUpMenuOptionsBase ()

	
	
	
    //====================Initialisation de l'ecran qui affiche le jour et les activites du jour ===============//
	
    /**
     * Methode qui permet d'initialiser le panel qui affiche les activites en fonction d'un jour donné
     * A l'intérieur on initialise consécutivement les différentes partie de l'écran (le haut, le centre et le bas).
     * On a factorisé ces parties pour éviter d'alourdir la  methode principale.
     */
    public void initJourPanel () {
    	
    	panelGlobal.removeAll ();//on enleve les composants du panel global
    	
    	//Initialisation des propriétés du panel global
    	panelGlobal.setLayout (new BorderLayout ());
    	panelGlobal.setBackground (Color.WHITE);
    	
    	//On initialise le panel du haut et ses proprietes
    	this.initJourPanelHaut ();
    	panelGlobal.add (panelJourHaut, BorderLayout.NORTH);
    	
    	//On initialise le panel du centre et ses proprietes 
    	this.initJourPanelCentre ();
    	panelGlobal.add (new JScrollPane (panelJourCentreSup), BorderLayout.CENTER);// on créé un JScrollPane pour pouvoir utiliser les scrollbar
    	
    	//On initialise le panel du bas et ses proprietes
    	this.initJourPanelBas ();
    	panelGlobal.add (panelJourBas, BorderLayout.SOUTH);
    	
    	panelGlobal.repaint ();//on repeint le panel avec les nouveaux composants
    }
    
    /**
     * Methode qui permet d'initialiser la partie haute du panel des jours,
     * c'est a dire le nom du jour, l'heure actuelle et la date du jour (qui est modifiable avec des boutons gauche/droite)
     * Elle sera appelée dans la méthode initJourPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans initJourPanel
     */
    private void initJourPanelHaut () {
    	
    	//On créé un nouveau panelDuHaut qu'on met en GridLayout de deux lignes et une colonne
    	panelJourHaut = new JPanel ();
    	panelJourHaut.setLayout (new GridLayout (2, 1));
    	panelJourHaut.setBackground (Color.white);
    	panelJourHaut.setPreferredSize (new Dimension (0, 100));
    	
    	//On y ajoute d'abord un label avec le nom du jour
    	jour = new JLabel (this.getNomDuJour (jourCourant), JLabel.CENTER);
    	jour.setFont (new Font ("Arial", Font.BOLD , 30));
    	jour.setForeground (Color.gray);
    	
    	//Puis on y ajoutera un panel qui contiendra l'heure et la date du jour (modifiable)
    	java.awt.Toolkit toolKit = java.awt.Toolkit.getDefaultToolkit ();
    	Image petiteBarreGrise = toolKit.getImage ("data/img/ancien/barreGrisePetite.png");
    	ImagePanel panelHeureEtJour = new ImagePanel (petiteBarreGrise);
    	panelHeureEtJour.setLayout (new GridLayout (2, 1));
    	panelHeureEtJour.setForeground (Color.white);
    	panelHeureEtJour.setBackground (Color.gray);
    	

    	
    	//#################   Gestion de l'Heure    ##############
    	
    	String heureCalendrier = String.valueOf (calendrier.get (Calendar.HOUR_OF_DAY));//on recupere l'heure actuelle
    	String minuteCalendrier = this.setMinuteAvec0 (calendrier.get (Calendar.MINUTE));//on recupere les minutes actuelle et on rajoute un 0 si besoin
    	
    	//On créé le label avec le format souhaité de l'heure et ajoutons les propriété graphiques
    	String heureCourante = heureCalendrier+ ":"+minuteCalendrier;
    	JLabel heure = new JLabel (heureCourante, JLabel.RIGHT);
    	heure.setForeground (Color.white);
    	panelHeureEtJour.add (heure);
    	
    	
    	//############### Gestion de la date modifiable   ##########"
    	
    	//On créé une image, puis on créé une ImagePanel de cette image (heritant de JPanel, qui permet de créer un panel avec une image de fond)
    	java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit ();
    	Image degradeOrange = toolkit.getImage ("data/img/ancien/degradeOrange.png");
    	ImagePanel panelJourImage = new ImagePanel (degradeOrange);
    	panelJourImage.setLayout (new FlowLayout ());
    	
    	//--------------- Bouton gauche/date précedente ---------------------
    	
    	//On créé le bouton gauche qui permettra d'aller au jour précédent. On lui affecte une image icone et des icones de rollover, etc.
    	ImageIcon flecheG = new ImageIcon ("data/img/ancien/flecheGB.png");
    	jourPrecedentBouton = new JButton (flecheG);
    	jourPrecedentBouton.setRolloverIcon (new ImageIcon ("data/img/ancien/flecheGriseGBRollOver2.png"));
    	jourPrecedentBouton.setPressedIcon (new ImageIcon ("data/img/ancien/flecheGriseGBRollOver.png"));
    	jourPrecedentBouton.setPreferredSize (new Dimension (20, 16));
    	jourPrecedentBouton.setMargin (new Insets (0,0,0,0));
    	jourPrecedentBouton.setContentAreaFilled (false);
    	jourPrecedentBouton.setToolTipText ("Jour precedent");
    	jourPrecedentBouton.addActionListener (listener);
    	jourPrecedentBouton.setActionCommand ("Jour precedent");
    	
    	//---------------- Date ---------------------
    	//On créé un panel blanc pour le design
    	JPanel dateDuJourPanel = new JPanel ();
    	dateDuJourPanel.setLayout (new BorderLayout ());
    	dateDuJourPanel.setPreferredSize (new Dimension (150, 16));
    	dateDuJourPanel.setMaximumSize (new Dimension (150, 16));
    	dateDuJourPanel.setMinimumSize (new Dimension (150, 16));
    	dateDuJourPanel.setBackground (Color.white);
    	
    	//On créé le String de la date (qui evolue) et on l'ajoute au panel blanc
    	String dateString = jourCourant +" "+this.getMoisDeIndex (moisCourant +1)+" "+anneeCourante;
    	JLabel dateDuJourText = new JLabel (dateString, JLabel.CENTER);
    	dateDuJourPanel.add (dateDuJourText, BorderLayout.NORTH);
    	
    	//------------------ Bouton droit/date suivante -------------------
    	ImageIcon flecheD = new ImageIcon ("data/img/ancien/flecheDB.png");
    	jourSuivantBouton = new JButton (flecheD);
    	jourSuivantBouton.setRolloverIcon (new ImageIcon ("data/img/ancien/flecheGriseDBRollOver2.png"));
    	jourSuivantBouton.setPressedIcon (new ImageIcon ("data/img/ancien/flecheGriseDBRollOver.png"));
    	jourSuivantBouton.setPreferredSize (new Dimension (20, 16));
    	jourSuivantBouton.setMargin (new Insets (0,0,0,0));
    	jourSuivantBouton.setContentAreaFilled (false);
    	jourSuivantBouton.setToolTipText ("Jour suivant");
    	jourSuivantBouton.addActionListener (listener);
    	jourSuivantBouton.setActionCommand ("Jour suivant");

    	//##################### Ajout consécutifs des sous panels et des panels  ###########################"
    	panelJourImage.add (jourPrecedentBouton);
    	panelJourImage.add (dateDuJourPanel);
    	panelJourImage.add (jourSuivantBouton);
    	
    	panelHeureEtJour.add (panelJourImage);
    	
    	panelJourHaut.add (jour);
    	panelJourHaut.add (panelHeureEtJour);
    	
    }
    
    /**
     * Methode qui permet d'initialiser la partie centre du panel des jours,
     * c'est a dire les activites existantes dans le jour (on affiche tout ce qui décrit cette activite). 
     * Ces activites sont affichées dans l'ordre chronologique.
     * Elle sera appelée dans la méthode initJourPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans initJourPanel
     */
    private void initJourPanelCentre () {
    	
    	//On créé un panel qui comprendra toutes les activites
    	panelJourCentreSup = new JPanel ();
    	panelJourCentreSup.setLayout (new FlowLayout ());
    	
    	JPanel panelJourCentre = new JPanel ();
    	panelJourCentre.setLayout (new BoxLayout (panelJourCentre, BoxLayout.Y_AXIS));//permet le bon affichage des activites
    	
    	//on parcours l'arrayList d'activites du jour qui sont dans l'ordre chronologique
    	for (int i=0; i< model.getListeActiviteDuJour (jourCourant, moisCourant, anneeCourante).size (); i++) {
    			
	    //On créé une activite qui contiendra successivement les activites du jour
	    Activite activite = model.getListeActiviteDuJour (jourCourant, moisCourant, anneeCourante).get (i);
			
			
	    //On créé un panel qui contiendra UNE activite (ces panel se succederont s'il y a plusieurs activites)
	    JPanel panelJour = new JPanel ();
	    panelJour.setLayout (new BorderLayout ());
    		
	    //#################### Informations concernant l'activite ########################
    		
	    JPanel panelJourInfos = new JPanel ();
	    panelJourInfos.setLayout (new BoxLayout (panelJourInfos, BoxLayout.Y_AXIS));//permet l'affichage en box
    		
	    //On ajoute d'abord le textPane du motif (a l'interieur on recupere le motif de l'activite), avec ses proprietes
	    JTextPane motifTextPane = new JTextPane ();
	    motifTextPane.setBackground (Color.white);
	    motifTextPane.setBorder (BorderFactory.createLineBorder (Color.gray));
	    motifTextPane.setEditable (false);
	    motifTextPane.setPreferredSize (new Dimension (140, 50));
	    motifTextPane.setText (activite.getMotif ());
    		
	    panelJourInfos.add (motifTextPane);//on l'ajoute au panel du jour
    		
	    if (! activite.getLieu ().equals ("")) {
		//Si le lieu n'a pas ete spécifié, on ne l'ajoute pas, sinon on l'ajoute
		JLabel lieuLabel = new JLabel ();
		lieuLabel.setText ("Lieu : "+activite.getLieu ());		
		panelJourInfos.add (lieuLabel);
	    }
    		
	    if (activite.getType ().equals ("RDV")) {
		//Si le type de l'activite est RDV
		Rdv rdv = (Rdv)activite;
    			
		if (! rdv.getInitiateur ().equals ("")) {
		    //Alors si l'initiateur n'a pas ete specifie, on ne l'ajoute pas, sinon on l'ajoute
		    JLabel initiateurLabel = new JLabel ();
		    initiateurLabel.setText ("Initiateur : "+rdv.getInitiateur ());
		    panelJourInfos.add (initiateurLabel);
		}
	    }
    		
	    if (activite.getType ().equals ("Cours")) {
		//Si le type de l'activite est Cours
		Cours cours = (Cours)activite;
    			
		if (! cours.getMatiere ().equals ("")) {
		    //Alors si la matiere n'a pas ete specifiee, on ne l'ajoute pas, sinon on l'ajoute
		    JLabel matiereLabel = new JLabel ();
		    matiereLabel.setText ("Matiere : "+cours.getMatiere ());	
		    panelJourInfos.add (matiereLabel);
		}
    			
		if (!cours.getProfesseur ().equals ("")) {
		    //Alors si le professeur n'a pas ete specifie, on ne l'ajoute pas, sinon on l'ajoute
		    JLabel professeurLabel = new JLabel ();
		    professeurLabel.setText ("Professeur : "+cours.getProfesseur ());
		    panelJourInfos.add (professeurLabel);
		}
    			
	    }
    		
	    if (activite.getType ().equals ("Reunion")) {
		//Si le type de l'activite est Reunion
		Reunion reunion = (Reunion)activite;
    			
		//on créé un vecteur de String qui contiendra les personnes
		//On a decide de prendre un Vecteur pour pouvoir l'ajouter a une JComboBox (impossible avec un ArrayList)
		Vector<String> listePersonneTableau = new Vector<String> ();
    			
		JPanel listePersonnePanel = new JPanel ();//on créé un panel qui comprendra un label (participants) et une JComboBox avec les participants
    			
		JLabel listePersonneLabel = new JLabel ();
    			
		StringTokenizer stringTokenizer = new StringTokenizer (reunion.getListePersonne (), ";");//on créé un tokenizer qui coupera la liste de personne a chaque ";" present. 
    			
		int j=0;
		//On compte le nombre de participants qu'il y a dans la liste
		//et on ajoute chaque personne dans le vecteur
    	        while (stringTokenizer.hasMoreTokens ()) {
    	            
		    listePersonneTableau.add (stringTokenizer.nextToken ());
		    j++;
    	        }
    	        
    	        // on créé la JComboBox avec la liste de participants
		JComboBox listePersonneBox = new JComboBox (listePersonneTableau);
		listePersonneBox.setMaximumRowCount (1);//On les affiche un a un, pour que le déroulement de la JComboBox ne depasse pas de l'ecran
    			
    	        if (j==0) {
		    //S'il n'y a pas de participants
		    //on dit qu'il n'y a aucun participant et on cache la JComboBox
		    listePersonneLabel.setText ("Aucun Participant");
		    listePersonneBox.setVisible (false);
    	        } else if (j==1) {
		    //Sinon s'il y a un participant on met a jour le label sous la forme (1 participant)
		    //On différencie pour ne pas mettre de "s" a participant
		    listePersonneLabel.setText (j+" Participant");
    	        } else {
		    //Sinon il ya plus qu'un participant et on met a jour le label en fonction du nombre de participants
		    listePersonneLabel.setText (j+" Participants");
    	        }
    	        
    			
		listePersonnePanel.add (listePersonneLabel);
		listePersonnePanel.add (listePersonneBox);
		panelJourInfos.add (listePersonnePanel);
	    }
    		
	    //############## Boutons editer et supprimer ###############
    		
	    //On ajoute un panel qui contiendra les boutons d'editer de supprimer
	    JPanel boutonsJourPanel = new JPanel ();
	    boutonsJourPanel.setLayout (new GridLayout (2,1));
    		
	    //Bouton editer et ses proprietes
	    JButton editerBouton = new JButton (new ImageIcon ("data/img/ancien/edit.png"));
	    editerBouton.setToolTipText ("Editer");//infobulle Editer
	    editerBouton.addActionListener (listener);
	    //on place un actionCommand sous la forme (edit+Id)
	    //On pourra ainsi récuperer l'id de l'activite a editer et sa fonction ("edit")
	    editerBouton.setActionCommand ("edit"+String.valueOf (activite.getId ()));
    		
	    //Bouton supprimer et ses proprietes
	    JButton supprimerBouton = new JButton (new ImageIcon ("data/img/ancien/suppr.png"));
	    supprimerBouton.setToolTipText ("Supprimer");//infobulle Supprimer
	    supprimerBouton.addActionListener (listener);
	    //on place un actionCommand sous la forme (suppr+Id)
	    //On pourra ainsi récuperer l'id de l'activite a supprimer et sa fonction ("suppr")
	    supprimerBouton.setActionCommand ("suppr"+String.valueOf (activite.getId ()));
    		
	    //Ajout des différents composants
	    boutonsJourPanel.add (editerBouton);
	    boutonsJourPanel.add (supprimerBouton);
    		
	    panelJour.add (panelJourInfos, BorderLayout.WEST);
	    panelJour.add (boutonsJourPanel, BorderLayout.EAST);
    		
	    panelJourCentre.add (panelJour);
    		
	    //############### Definition de la TitledBorder  ###############
    		 
	    //on defini un String titre qui sera de la forme : "RDV : 14:00 a 15:00"
	    String titre = activite.getType ()+" : "+activite.getHeureDebut ()+":"+this.setMinuteAvec0 (activite.getMinuteDebut ())
		+" a "+activite.getHeureFin ()+":"+this.setMinuteAvec0 (activite.getMinuteFin ());
    		
	    //on cree un TitledBorder en fonction du string precedent (titre a gauche) et on l'ajoute au panel du jour
	    TitledBorder title = BorderFactory.createTitledBorder (BorderFactory.createEtchedBorder (EtchedBorder.LOWERED), titre);
	    title.setTitleJustification (TitledBorder.LEFT);
	    panelJour.setBorder (title);
    		
    	}
    	
    	
    	panelJourCentreSup.add (panelJourCentre);
    	
    }// ----------------------------------------------------------- initJourPanelCentre ()
    
    /**
     * Methode qui permet d'initialiser la partie bas du panel des jours,
     * c'est a dire les boutons ajouter Act. et le bouton retour. Le bouton ajouter activite comprend les 4 types d'activites (autre, rdv, reunion, cours)
     * Elle sera appelée dans la méthode initJourPanel. En fait, cette méthode est un méthode de factorisation 
     * pour éviter l'abondance de code dans initJourPanel
     */
    private void initJourPanelBas () {
    	
    	//on initialise le panel bas et ses propriétés
    	panelJourBas = new JPanel ();
    	panelJourBas.setLayout (new GridLayout (1, 2));
    	panelJourBas.setPreferredSize (new Dimension (0, 30));
    	panelJourBas.setMinimumSize (new Dimension (0, 30));
    	
    	//################ Gestion des boutons options et retour ##################
    	
    	//On initialise le bouton options et ses propriétés
    	nouvelleActivite = new JButton ();
    	nouvelleActivite.setText ("Ajouter Act.");
    	nouvelleActivite.setFont (new Font ("Arial", Font.BOLD , 20));
    	nouvelleActivite.addActionListener (listener);
    	nouvelleActivite.setActionCommand ("OptionsActivite");
    	
    	//On initialise le bouton retour et ses propriétés
    	retour = new JButton ("Retour");
    	retour.setFont (new Font ("Arial", Font.BOLD , 20));
    	retour.setEnabled (true);
    	retour.addActionListener (listener);
    	retour.setActionCommand ("retourJourVersCalendrier");
    	
    	
    	this.initPopUpMenuOptionsActivite ();
		
	//############### Ajout des boutons #################"
		
	//On ajoute les deux boutons au panel du bas
	panelJourBas.add (nouvelleActivite);
    	panelJourBas.add (retour);
    	
    	
    }// ----------------------------------------------------------- initJourPanelBas ()
    
    /**
     * Methode qui permet d'initialiser le menu popUp qui apparait 
     * lorsqu'on clique sur le bouton "ajouter activite" dans le panel d'un jour precis
     * Il contient en fait les differents types d'activite qui peuvent etre crees :
     * <ul>
     * 		<li>RDV</li>
     *  	<li>Cours</li>
     *  	<li>Reunion</li>
     *  	<li>Autre</li>
     * </ul>
     */
    private void initPopUpMenuOptionsActivite () {
		
	//#################### Gestion du menu popup du bouton options ###############
		
	//On initialise le menu popup qui s'affichera pour le bouton options
	popUpMenuActivite = new JPopupMenu ();
		
	//On initialise le menu nouvelle activité et ses sous menus (rdv, cours, etc.)
	JMenuItem rdvActivite = new JMenuItem ("RDV");
	rdvActivite.addActionListener (listener);
	JMenuItem coursActivite = new JMenuItem ("Cours");
	coursActivite.addActionListener (listener);
	JMenuItem reunionActivite = new JMenuItem ("Reunion");
	reunionActivite.addActionListener (listener);
	JMenuItem autreActivite = new JMenuItem ("Autre");
	autreActivite.addActionListener (listener);
		
	//On ajoute les menus dans le popup
	popUpMenuActivite.add (rdvActivite);
	popUpMenuActivite.add (coursActivite);
	popUpMenuActivite.add (reunionActivite);
	popUpMenuActivite.add (autreActivite);
		
	estPasseParMenuPopUpActivite = true;
		
    }// ----------------------------------------------------------- initPopUpMenuOptionsActivite ()

	
    /**
     * Methode qui permet de changer les minutes en fonction de si elles sont inferieures à 10 ou non.
     * Cela, a fin d'afficher un 0 devant les minutes < 10.
     * Par exemple 10 heures 5 min, doit s'affiche 10:05 et non 10:5
     * @param minutes les minutes a verifier si <10
     * @return le String changé (si minutes <10, on a rajouté un 0)
     */
    public String setMinuteAvec0 (int minutes) {
    	
    	if ( minutes < 10) {
	    //Si les minutes sont inférieures a 10
	    //alors on renvoit une string comportant un 0 suivi des minutes
	    String minutesString = "0"+String.valueOf (minutes);
	    return minutesString;
    	} else {
	    //Alors on renvoit par defaut les minutes converties en String
	    String minutesString = String.valueOf (minutes);
	    return minutesString;
    	}
    	
    }// ----------------------------------------------------------- setMinuteAvec0 (minutes : int)
    
    /**
     * Methode qui permet de passer au jour precedent
     * Cette methode gere si l'on est le 1 du mois et que l'on passe au dernier jour du mois precedent 
     * (idem pour passer de janvier N à decembre N-1)
     */
    public void setJourPrecedent () {
    	
    	if (jourCourant >1) {
	    //Si le jour Courant est superieur à 1 (2, 3, etc.)
	    //Alors on peut passer au jour precedent sans probleme
	    jourCourant -= 1;
    	} else {
	    //Sinon
	    if ( (jourCourant == 1) && (moisCourant == 0)) {
		//Si le jourCourant est le 1er du mois, que le mois est janvier
		//Alors le jourCourant prend la valeur du nombre de jour du mois de decembre de l'annee precedente (correspond au dernier jour du mois)
		jourCourant = this.calculeNbJoursMois (11, anneeCourante -1);
	    } else
		//Sinon le jour courant prend la valeur du nombre de jour du mois precedent de l'annee courante
		jourCourant = this.calculeNbJoursMois ( (moisCourant - 1), anneeCourante); 
    	} 
    		
    }// ----------------------------------------------------------- setJourPrecedent ()
    
    /**
     * Methode qui permet de passer au jour suivant
     * Cette methode gere si l'on est le 1 du mois et que l'on passe au dernier jour du mois suivant
     * (idem pour passer de decembre N à janvier N+1)
     */
    public void setJourSuivant () {
    	
    	if (jourCourant < this.calculeNbJoursMois (moisCourant, anneeCourante)) {
	    //Si le jour suivant est inferieur au dernier jour du mois courant, de l'annee courante
	    //Alors on peut passer sans probleme au jour suivant
	    jourCourant += 1;
    	} else {
	    //Sinon 
    	
    		
	    if ( (jourCourant == 31) && (moisCourant == 11)) {
		//Si on est au dernier jour de decembre
    			
		jourCourant = 1;//on va au premier jour du mois
		moisCourant = 0;//le mois est janvier
		anneeCourante += 1;//l'annee courante prend une annee de plus
    			
	    } else {
		//Sinon
		jourCourant = 1;//on va au premier jour du mois
		moisCourant += 1;//on passe au mois suivant
	    }

    	}
    }// ----------------------------------------------------------- setJourSuivant ()
    
    
    
    //=================== Initialisation de l'ecran d'ajout d'une activite (suivant le type) ====================//
    
    /**
     * Methode graphique qui permet d'afficher les composants permettant d'ajouter une activite par defaut
     * Elle est appelee dans les autres methodes qui initialisent les autres ajout d'activite (rdv, cours, reunion)
     * Elle est separee en 3 parties:<br/>
     * -Haut : affichage du type de l'activite dans un fond de degrade orange
     * -Centre : affichage des Label et JTextField pour chaque parametre definissant une activite
     * -Bas : bouton "enregistrer" et "retour"
     */
    public void initNouvelleActiviteDefaut () {
    	
    	panelGlobal.removeAll ();
    	
    	//############### Haut #################"
    	
    	java.awt.Toolkit toolkit = java.awt.Toolkit.getDefaultToolkit ();
    	Image degradeOrange = toolkit.getImage ("data/img/ancien/degradeOrange.png");
    	ImagePanel panelHautActivite = new ImagePanel (degradeOrange);
    	panelHautActivite.setPreferredSize (new Dimension (0, 60));
    	typeActivite = new JLabel ("Autre");
    	typeActivite.setFont (new Font ("Arial", Font.BOLD , 35));
    	typeActivite.setForeground (Color.white);
    	panelHautActivite.add (typeActivite);

    	//############## CENTRE ###############
    	//On y ajoute consécutivement les différents champs et labels
    	
    	JPanel panelCentreActiviteSup = new JPanel ();
    	panelCentreActiviteSup.setLayout (new FlowLayout ());
    	
    	panelCentreActivite = new JPanel ();
    	panelCentreActivite.setLayout (new BoxLayout (panelCentreActivite, BoxLayout.Y_AXIS));//permet d'afficher les activites correctement
    	
    	//---------Motif-------------
    	JPanel motifPanel = new JPanel ();
    	motifPanel.setLayout (new BorderLayout ());
    	JLabel motif = new JLabel ("Motif");
    	motifText = new JEditorPane ();
    	motifText.setBackground (Color.white);
    	motifText.setPreferredSize (new Dimension (200, 60));
    	motifPanel.add (motif, BorderLayout.WEST);
    	motifPanel.add (new JScrollPane (motifText), BorderLayout.EAST);
    	panelCentreActivite.add (motifPanel);
    	
    	//--------Date---------------
    	JPanel datePanel = new JPanel ();
    	datePanel.setLayout (new BorderLayout ());
    	JLabel date = new JLabel ("Date");
    	JPanel datePanelDroite = new JPanel ();
    	datePanelDroite.setLayout (new FlowLayout ());
    	dateJourText = new JTextField (2);
    	dateMoisText = new JTextField (2);
    	dateAnneeText = new JTextField (4);
    	datePanelDroite.add (dateJourText);
    	datePanelDroite.add (new JLabel ("/"));
    	datePanelDroite.add (dateMoisText);
    	datePanelDroite.add (new JLabel ("/"));
    	datePanelDroite.add (dateAnneeText);
    	
    	datePanel.add (date, BorderLayout.WEST);
    	datePanel.add (datePanelDroite, BorderLayout.EAST);
    	
    	panelCentreActivite.add (datePanel);
    	
    	//--------HeureDebut----------
    	JPanel heureDebutPanel = new JPanel ();
    	heureDebutPanel.setLayout (new BorderLayout ());
    	JLabel heureDebut = new JLabel ("heure de debut");
    	JPanel heureDebutPanelDroite = new JPanel ();
    	heureDebutPanelDroite.setLayout (new FlowLayout ());
    	heureDebutH = new JTextField (2);
    	heureDebutM = new JTextField (2);
    	heureDebutPanelDroite.add (heureDebutH);
    	heureDebutPanelDroite.add (new JLabel (":"));
    	heureDebutPanelDroite.add (heureDebutM);
    	
    	heureDebutPanel.add (heureDebut, BorderLayout.WEST);
    	heureDebutPanel.add (heureDebutPanelDroite, BorderLayout.EAST);
    	
    	panelCentreActivite.add (heureDebutPanel);
    	
    	//--------HeureFin------------
    	
    	JPanel heureFinPanel = new JPanel ();
    	heureFinPanel.setLayout (new BorderLayout ());
    	JLabel heureFin = new JLabel ("heure de fin");
    	JPanel heureFinPanelDroite = new JPanel ();
    	heureFinPanelDroite.setLayout (new FlowLayout ());
    	heureFinH = new JTextField (2);
    	heureFinM = new JTextField (2);
    	heureFinPanelDroite.add (heureFinH);
    	heureFinPanelDroite.add (new JLabel (":"));
    	heureFinPanelDroite.add (heureFinM);
    	
    	heureFinPanel.add (heureFin, BorderLayout.WEST);
    	heureFinPanel.add (heureFinPanelDroite, BorderLayout.EAST);
    	
    	panelCentreActivite.add (heureFinPanel);
    	
    	//-----------Lieu---------------
    	JPanel lieuPanel = new JPanel ();
    	lieuPanel.setLayout (new BorderLayout ());
    	JLabel lieu = new JLabel ("Lieu");
    	lieuText = new JTextField (15);
    	lieuPanel.add (lieu, BorderLayout.WEST);
    	lieuPanel.add (lieuText, BorderLayout.EAST);
    	panelCentreActivite.add (lieuPanel);   	
    	
    	panelCentreActiviteSup.add (panelCentreActivite);
    	
    	//################### BAS ######################
    	
    	JPanel panelBasActivite = new JPanel ();
    	panelBasActivite.setLayout (new GridLayout (1, 2));
    	panelBasActivite.setPreferredSize (new Dimension (0, 30));
    	panelBasActivite.setMinimumSize (new Dimension (0, 30));
    	
    	//-------------- Gestion des boutons options et retour --------------
    	
    	//On initialise le bouton options et ses propriétés
    	enregistrerActivite = new JButton ("Enregistrer");
    	enregistrerActivite.setFont (new Font ("Arial", Font.BOLD , 20));
    	enregistrerActivite.addActionListener (listener);
    	
    	//On initialise le bouton retour et ses propriétés
    	retourActivite = new JButton ("Retour");
    	retourActivite.setFont (new Font ("Arial", Font.BOLD , 20));
    	retourActivite.addActionListener (listener);
    	retourActivite.setActionCommand ("retourActiviteVersCalendrier");
    	
		
	//On ajoute les deux boutons au panel du bas
	panelBasActivite.add (enregistrerActivite);
    	panelBasActivite.add (retourActivite);
    	
    	//#################Ajout des panel du haut, du centre et du bas #####################
    	
    	panelGlobal.add (panelHautActivite, BorderLayout.NORTH);
    	panelGlobal.add (new JScrollPane (panelCentreActiviteSup), BorderLayout.CENTER);
    	panelGlobal.add (panelBasActivite, BorderLayout.SOUTH);
    	
    	panelGlobal.repaint ();
    }// ----------------------------------------------------------- initNouvelleActiviteDefaut ()
    
    /**
     * Methode qui vient en complement de initNouvelleActiviteDefaut () car elle permet d'ajouter en plus l'initiateur décrivant un RDV
     * On y appelle la methode initNouvelleActiviteDefaut () et on ajoute des panels avec les composants correspondants
     * Elle est appelée lorsqu'on clique sur Ajouter Activite > Rdv
     */
    public void initNouvelleActiviteRDV () {
    	
    	this.initNouvelleActiviteDefaut ();//On appelle la methode d'initialisation d'une activite par defaut

    	typeActivite.setText ("RDV");//on met a jour le type de l'activite
    	
    	//On ajoute un panel dans lequel on ajoute un Label ("Initiateur") et un JTextField pour saisir l'initiateur
    	JPanel initiateurPanel = new JPanel ();
    	initiateurPanel.setLayout (new BorderLayout ());
    	JLabel initiateur = new JLabel ("Initiateur");
    	initiateurText = new JTextField (15);
    	initiateurPanel.add (initiateur, BorderLayout.WEST);
    	initiateurPanel.add (initiateurText, BorderLayout.EAST);
    	panelCentreActivite.add (initiateurPanel);

    	
    	panelGlobal.repaint ();
    	
    }// ----------------------------------------------------------- initNouvelleActiviteRdv ()
    
    /**
     * Methode qui vient en complement de initNouvelleActiviteDefaut () car elle permet d'ajouter en plus les participants décrivant un Reunion
     * On y appelle la methode initNouvelleActiviteDefaut () et on ajoute des panels avec les composants correspondants
     * Elle est appelée lorsqu'on clique sur Ajouter Activite > Reunion
     */
    public void initNouvelleActiviteReunion () {
    	
    	this.initNouvelleActiviteDefaut ();//On appelle la methode d'initialisation d'une activite par defaut
    	
    	typeActivite.setText ("Reunion");//on met a jour le type de l'activite
    	
    	//On ajoute un panel dans lequel on ajoute un Label ("Participants") et un JTextField pour saisir les participants
    	JPanel listePersonnePanel = new JPanel ();
    	listePersonnePanel.setLayout (new BorderLayout ());
    	JLabel listePersonne = new JLabel ("Participants *");
    	listePersonneText = new JTextField (13);
    	listePersonnePanel.add (listePersonne, BorderLayout.WEST);
    	listePersonnePanel.add (listePersonneText, BorderLayout.EAST);
    	panelCentreActivite.add (listePersonnePanel);
    	
    	//On ajoute un label qui informe de mettre les participants sous la forme p1;p2;p3
    	JLabel attention = new JLabel ("* sous la forme p1;p2;p3");
    	attention.setFont (new Font ("Arial", Font.PLAIN, 10));
    	panelCentreActivite.add (attention);
    	
    	panelGlobal.repaint ();
    }// ----------------------------------------------------------- initNouvelleActiviteReunion ()
    
    /**
     * Methode qui vient en complement de initNouvelleActiviteDefaut () car elle permet d'ajouter en plus la matiere et le professeur décrivant un Cours
     * On y appelle la methode initNouvelleActiviteDefaut () et on ajoute des panels avec les composants correspondants
     * Elle est appelée lorsqu'on clique sur Ajouter Activite > Cours
     */
    public void initNouvelleActiviteCours () {
    	
    	this.initNouvelleActiviteDefaut ();//On appelle la methode d'initialisation d'une activite par defaut
    	
    	//On ajoute ensuite les champs qui font la différence avec une activite basique
    	
    	typeActivite.setText ("Cours");//on met a jour le type de l'activite
    	
    	//On ajoute un panel dans lequel on ajoute un Label ("Matiere") et un JTextField pour saisir la matiere 
    	JPanel matierePanel = new JPanel ();
    	matierePanel.setLayout (new BorderLayout ());
    	JLabel matiere = new JLabel ("Matiere");
    	matiereText = new JTextField (15);
    	matierePanel.add (matiere, BorderLayout.WEST);
    	matierePanel.add (matiereText, BorderLayout.EAST);
    	panelCentreActivite.add (matierePanel);
    	
    	//On ajoute un panel dans lequel on ajoute un Label ("Professeur") et un JTextField pour saisir le professeur 	
    	JPanel professeurPanel = new JPanel ();
    	professeurPanel.setLayout (new BorderLayout ());
    	JLabel professeur = new JLabel ("Professeur");
    	professeurText = new JTextField (15);
    	professeurPanel.add (professeur, BorderLayout.WEST);
    	professeurPanel.add (professeurText, BorderLayout.EAST);
    	panelCentreActivite.add (professeurPanel);
	
    	panelGlobal.repaint ();
    	
    }// ----------------------------------------------------------- initNouvelleActiviteCours ()
    
    
    
    /**
     * Methode qui permet d'ajouter une activite. Plusieurs tests consécutifs sont executes dans un ordre précis avant d'ajouter l'activite.
     * On vérifie d'abord si les champs obligatoires sont remplis, ensuite si les textes entrees dans la date et les heures sont bien des int,
     * Puis on vérifie la date, l'heure et les minutes (0<=heure<24, etc.). Par la suite, on vérifie si l'heure de début est avant l'heure de fin, 
     * et enfin on vérifie si l'activité créé ne chevauche pas une autre.
     * Toutes les vérifications ont un message d'erreur spécifique qui informe l'utilisateur de son erreur.
     * Cette methode est appellee lorsque l'utilisateur clique sur "enregistrer" quand il veut ajouter une nouvelle activite
     * @return vrai si l'activite a ete ajoutee, faux dans le cas contraire
     */
    public boolean ajouterActivite () {
	    	
	if (this.verifierChamps ()) {
	    //Si aucune des champs obligatoire n'est vide
	    		
	    if (this.verifierInt ()) {
		//Si les textes entres dans la date et les heures sont des entiers (On doit prendre en compte cela car une exception apparait lors du parsing Int si les text ne sont pas des entiers)
	    			
		if (this.verifierDate () && this.verifierHeures () && this.verifierMinutes ()) {
		    //Si la date et les heures sont vérifiees ( l'heure doit etre comprise entre 0 et 23 compris, etc.)
			    		
		    if (this.verifierHeureDebutAvantFin ()) {
			//Si l'heure de fin est supérieure à l'heure de debut
			    			
			id = model.size ();//l'id a ajouter prend la valeur de la taille du model (activites ont un id unique)
					    	
			//On récupère les textes des champs et on les convertis si besoin en entier (date, et heures)
			String motif = motifText.getText ();
			int heureDebut = Integer.parseInt (heureDebutH.getText ());
			int heureFin = Integer.parseInt (heureFinH.getText ());
			int minuteDebut = Integer.parseInt (heureDebutM.getText ());
			int minuteFin = Integer.parseInt (heureFinM.getText ());
			int jour = Integer.parseInt (dateJourText.getText ());
			int mois = Integer.parseInt (dateMoisText.getText ());
			int annee = Integer.parseInt (dateAnneeText.getText ());
			String lieu = lieuText.getText ();
			String type = typeActivite.getText ();
					    	
			if (typeActivite.getText () == "RDV") {
			    //Si le type d'activite est un RDV
			    if (model.ajouterActivite (new Rdv (id , motif, heureDebut, heureFin, minuteDebut, minuteFin, jour, mois, annee, lieu,type, initiateurText.getText ()))) {
				//Si on peut ajouter le rdv
				this.sauvegarde ();//on sauvegarde
				JOptionPane.showMessageDialog (panelGlobal, "Le rdv a bien ete ajoute", "Rdv ajoute", JOptionPane.INFORMATION_MESSAGE); //on informe l'utilisateur que son activite a bien ete ajoutee
				System.out.println ("ajout d'un RDV");
				return true;//on renvoit vrai, le rdv a ete ajoute
			    } else {
				//Sinon on affiche un message d'erreur et on renvoit faux
				JOptionPane.showMessageDialog (panelGlobal,
							       "Une activite existe deja dans ces heures la !\nVeuillez changer votre date et/ou les heures.",
							       "Erreur : Chevauchement d'activite !",
							       JOptionPane.ERROR_MESSAGE);
				return false;
			    }
			} else if (typeActivite.getText () == "Cours") {
			    //Sinon si le type est Cours
					    	
			    if (model.ajouterActivite (new Cours (id, motif, heureDebut, heureFin, minuteDebut, minuteFin, jour, mois, annee, lieu,type, matiereText.getText (),professeurText.getText () ))) {
				//Si on peut ajouter le cours
				this.sauvegarde ();//on sauvegarde
				JOptionPane.showMessageDialog (panelGlobal, "Le cours a bien ete ajoute", "Cours ajoute", JOptionPane.INFORMATION_MESSAGE); 
				System.out.println ("ajout d'un Cours");
				return true;
			    } else {
				JOptionPane.showMessageDialog (panelGlobal,
							       "Une activite existe deja dans ces heures la !\nVeuillez changer votre date et/ou les heures.",
							       "Erreur : Chevauchement d'activite !",
							       JOptionPane.ERROR_MESSAGE);
				return false;
			    }
			} else if (typeActivite.getText () == "Reunion") {
			    //Sinon si le type est une reunion
					    	
			    if (model.ajouterActivite (new Reunion (id, motif, heureDebut, heureFin, minuteDebut, minuteFin, jour, mois, annee, lieu,type, listePersonneText.getText ()))) {
				//Si on peut ajouter la reunion
				this.sauvegarde ();
				JOptionPane.showMessageDialog (panelGlobal, "La reunion a bien ete ajoutee", "Reunion ajoutee", JOptionPane.INFORMATION_MESSAGE); 
				System.out.println ("ajout d'une Reunion");
				return true;
			    } else {
				JOptionPane.showMessageDialog (panelGlobal,
							       "Une activite existe deja dans ces heures la !\nVeuillez changer votre date et/ou les heures.",
							       "Erreur : Chevauchement d'activite !",
							       JOptionPane.ERROR_MESSAGE);
				return false;
			    }
			} else {
			    //Sinon
					    	
			    if (model.ajouterActivite (new Activite (id , motif, heureDebut, heureFin, minuteDebut, minuteFin, jour, mois, annee, lieu,type))) {
				//Si on peut ajouter l'activite par defaut
				this.sauvegarde ();
				JOptionPane.showMessageDialog (panelGlobal, "L'activite autre a bien ete ajoutee", "Activite autre ajoutee", JOptionPane.INFORMATION_MESSAGE); 
				System.out.println ("ajout d'une Activite autre");
				return true;
			    } else {
				JOptionPane.showMessageDialog (panelGlobal,
							       "Une activite existe deja dans ces heures la !\nVeuillez changer votre date et/ou les heures.",
							       "Erreur : Chevauchement d'activite !",
							       JOptionPane.ERROR_MESSAGE);
				return false;
			    }
			}
		    } else {
			//Sinon (si l'heure de debut est superieure ou egale a l'heure de fin)
			//On affiche un message d'erreur a l'attention de l'utilisateur
			JOptionPane.showMessageDialog (panelGlobal,
						       "L'heure du début doit etre inferieure a l'heure de fin !\nVeuillez vérifier les heures donnees",
						       "Erreur : Incohérence des heures !",
						       JOptionPane.ERROR_MESSAGE);
			    			
			return false;//On retourne faux car l'activite n'a pas ete cree
		    }
		} else
		    //Sinon (si les dates et les heures ne sont pas verifiees)
		    return false;//On retourne faux car l'activite n'a pas ete cree
	    } else {
		//Sinon (si les dates et heures entrees ne sont pas des entiers)
		//on affiche un message d'erreur à l'attention de l'utilisateur
		JOptionPane.showMessageDialog (panelGlobal,
					       "La date et les heures doivent etre des nombres\nentiers de 2 chiffres (sauf l'annee)",
					       "Error : Nombres entiers demandes !",
					       JOptionPane.ERROR_MESSAGE);
		return false;//On retourne faux car l'activite n'a pas ete cree
	    }
	} else {
	    //Sinon (si un champs obligatoire n'a pas ete rempli)
	    //on affiche un message d'erreur à l'attention de l'utilisateur
	    JOptionPane.showMessageDialog (panelGlobal,
					   "Certains champs de texte ne sont pas remplis\nLe motif, la date et les heures sont obligatoires",
					   "Error : champs manquants",
					   JOptionPane.ERROR_MESSAGE);
	    		
	    return false;//On retourne faux car l'activite n'a pas ete cree
	}
	
    }// ----------------------------------------------------------- ajouterActivite ()


    /**
     * Methode qui permet de mettre a jour les JTextField de la date lorsqu'on clique sur un jour.
     * Par exemple, par defaut, quand on clique sur le 12 du mois de decembre 2008, la date par defaut 12/12/2008 sera definie
     * Si le jour n'a pas ete defini, on met par defaut le mois et l'annee courants
     */
    public void setDateCliquee () {
    	
    	if (jourCourant != 0)
	    //Si le jour courant est différent de 0 (cad que le jour Courant a ete defini)
	    //alors on met a jour le JTextField avec la valeur du jourCourant
	    dateJourText.setText (String.valueOf (jourCourant));
    	else
	    //Sinon si le jour courant n'a pas ete defini
	    //On efface le contenu du JTextField
	    dateJourText.setText ("");
    	
    	//On met a jour les JTextField au moisCourant et a l'anneeCourante
    	dateMoisText.setText (String.valueOf (moisCourant+1));
    	dateAnneeText.setText (String.valueOf (anneeCourante));
    }// ----------------------------------------------------------- setDateCliquee ()
    
    
    //================ Verifications a faire lors de l'ajout et de la modification d'une activite ================//
    
    /**
     * Methode qui verifie si tous les champs obligatoire ont ete remplis. C'est a dire la date, les heures et le motif.
     * Cette methode est appelee en tout premier lors de l'ajout d'une activite
     * @return vrai si les champs obligatoire ont tous ete remplis, faux dans le cas contraire
     */
    
    public boolean verifierChamps () {
		
	//On recupere les champs de texte
	String heureFin = heureFinH.getText ();
	String heureDebut= heureDebutH.getText ();
	String minuteFin = heureFinM.getText ();
	String minuteDebut = heureDebutM.getText ();
	String jour = dateJourText.getText ();
	String mois = dateMoisText.getText ();
	String annee = dateAnneeText.getText ();
	String motif = motifText.getText ();
		
	if (  (heureDebut.equals ("")) || (heureFin.equals ("") ) 
	      || (jour.equals ("") ) || (minuteDebut.equals ("") ) 
	      || (minuteFin.equals ("")) || (jour.equals (""))
	      || (mois.equals ("")) || (annee.equals ("")) || (motif.equals ("")) ) {
	    //Si un des champs obligatoire n'est pas remplis
	    //alors on retourne faux
	    return false;
	} else {
	    //Sinon
		
	    //on retourne vrai
	    return true;
			
	}
    }// ----------------------------------------------------------- verifierChamps ()
    
    /**
     * Methode qui verifie si les dates et heures entres sont des entiers de 2 chiffres (sauf pour annee).
     * On utilise pour cela Regex qui permet de savoir si une chaine se trouve dans une autre.
     * Elle est appelee lors de l'ajoute d'une activite. Sans cela, une exception apparaitra lors de la conversion en Int des dates et des heures
     * (chose qui a lieu lors des vérification suivantes)
     * On fait donc cette verification juste apres la verification des champs
     * @return vrai si la date et les heures sont des entiers (2 chiffres, sauf pour l'annee), faux dans le cas contraire
     */
	
    public boolean verifierInt () {
		
	/*On cree un pattern pour les nombres de 2 chiffres ou moins
	 *Description du pattern : debut de ligne - 2 chiffres compris entre 0 et 9 et seulement ça OU 1 chiffre compris entre 0 et 9 et seulement ça - fin de ligne
	 */
    	Pattern nombre2Chiffres = Pattern.compile ("^ ( ([0-9][0-9])| ([0-9]))$");
    	
    	//On cree des matcher qui recuperent les textes des heures et de la date (sauf l'annee) et on leur applique le pattern à 2 chiffres
    	Matcher heureDebutMatcher = nombre2Chiffres.matcher (heureDebutH.getText ());
    	Matcher minuteDebutMatcher = nombre2Chiffres.matcher (heureDebutM.getText ());
    	Matcher heureFinMatcher = nombre2Chiffres.matcher (heureFinH.getText ());
    	Matcher minuteFinMatcher = nombre2Chiffres.matcher (heureFinM.getText ());
    	Matcher jourMatcher = nombre2Chiffres.matcher (dateJourText.getText ());
    	Matcher moisMatcher = nombre2Chiffres.matcher (dateMoisText.getText ());
    	
    	/*On cree un patter pour l'annee (un nombre)
    	 *Description du pattern : debut de ligne -Une suite de plusieurs chiffres compris entre 0 et 9 (= nombre) et seulement ça- fin de ligne
    	 */
    	Pattern nombre = Pattern.compile ("^ (\\G ( ([0-9])*)\\z)$");
    	//On cree un matcher qui recupere le texte de l'annee et on lui applique le pattern du nombre
    	Matcher anneeMatcher = nombre.matcher (dateAnneeText.getText ());
    	
    	if (heureDebutMatcher.find () && minuteDebutMatcher.find () && heureFinMatcher.find () && minuteFinMatcher.find () && anneeMatcher.find () && jourMatcher.find () && moisMatcher.find () ) {
	    //Si on trouve seulement des entiers dans les textes
	    //on retourne vrai
	    return true;
    	}
	//sinon on retourne faux
	return false;
		
    }// ----------------------------------------------------------- verifierInt ()
	
    /**
     * Methode qui verifie si la date donnee existe. 
     * C'est a dire si le mois est compris entre 0 et 12, que le jour existe dans le mois (30 n'existe pas dans fevrier)
     * Elle est appelee lors de l'ajout d'une activite
     * @return vrai si la date existe, faux dans le cas contraire
     */
    public boolean verifierDate () {
		
	int jour = Integer.parseInt (dateJourText.getText ());//on convertit le jour donne en entier
	int mois = Integer.parseInt (dateMoisText.getText ()) - 1; //on convertit le mois donne en entier et on lui retire 1 car le premier mois = 0
	int nbJoursMois = this.calculeNbJoursMois (mois, Integer.parseInt (dateAnneeText.getText ()));//on recupere le nombre de jour du mois en fonction de l'annee
	//l'annnee n'a pas besoin d'etre verifiee car elle n'a pas de limites
		
	if ( (mois <= 11) && (mois >= 0) && (jour > 0) && (jour <= nbJoursMois)) {
	    //Si le mois est compris entre 0 et 11 compris et que le jour est positif et inferieur ou egal au nombre de jour dans le mois
	    return true;//Alors on retourne vrai
	} else {
	    //Sinon
	    //On affiche le message d'erreur correspondant
	    JOptionPane.showMessageDialog (panelGlobal,
					   "La date que vous avez inscrite n'existe pas\nVeuillez vérifier vos nombres",
					   "Erreur : date inexistante",
					   JOptionPane.ERROR_MESSAGE);
			
	    return false;//et on retourne faux
	}
		
    }// ----------------------------------------------------------- verifierDate ()
	
    /**
     * Methode qui permet de vérifier si les minutes sont comprises entre 0 et 59 (compris)
     * @return vrai si les minutes sont existantes (0<minutes<60), faux dans le cas contraire
     */
    public boolean	verifierMinutes () {
		
	//on récupere la minute de fin de debut
	String minuteFin = heureFinM.getText ();
	String minuteDebut= heureDebutM.getText ();
		
	if ( (Integer.parseInt (minuteDebut) >= 0 ) && (Integer.parseInt (minuteFin) >= 0 ) && (Integer.parseInt (minuteDebut) < 60) && (Integer.parseInt (minuteFin) < 60)) {
	    //Si la minute de debut et la minute de fin sont comprises entre 0 et 59 (compris)
	    //alors on retourn vrai, le test est verifie
	    return true;
	} else {
	    //Sinon
	    //On affiche le message d'erreur correspondant, a l'attention de l'utilisateur
	    JOptionPane.showMessageDialog (panelGlobal,
					   "Les minutes saisies doivent etre comprise entre 0 et 59.",
					   "Erreur : mauvaises minutes",
					   JOptionPane.ERROR_MESSAGE);
	    //alors on retourn faux, le test n'est pas verifie
	    return false;					
	}
    }// ----------------------------------------------------------- verifierMinutes ()
	
	
    /**
     * Methode qui permet de vérifier si l'heure de debut est avant l'heure de fin.
     * Pour cela on vérifie les deux heures, si elles sont egales, il faut egalement vérifier les minutes
     * @return vrai si l'heure de debut est avant l'heure de fin
     */
    public boolean verifierHeureDebutAvantFin () {
		
	//On récupere les entiers qui correspondent aux heures (heures et minutes)
	int heureFin = Integer.parseInt (heureFinH.getText ());
	int heureDebut= Integer.parseInt (heureDebutH.getText ());
	int minuteFin = Integer.parseInt (heureFinM.getText ());
	int minuteDebut= Integer.parseInt (heureDebutM.getText ());
		
	if ( heureFin > heureDebut) {
	    //Si l'heure de fin est apres l'heure de debut
	    //on retourne vrai, le test est verifie
	    return true;
	} else if ( heureFin == heureDebut) {
	    //Sinon si l'heure de fin est egale a l'heure de debut
	    //Alors on vérifie les minutes
	    if (minuteFin > minuteDebut) {
		//Si la minute de fin est apres la minute de debut 
		//on retourne vrai, le test est verifie
		return true;
	    } else {
		//Sinon
			
		//on retourne faux
		return false;
	    }
			
	} else {
	    //Sinon on retourne faux
		
	    return false;
	}
		
    }// ----------------------------------------------------------- verifierHeureDebutAvantFin ()
    
    /**
     * Methode qui permet de vérifier si l'heure de debut et l'heure de fin existent,
     *  c'est à dire elles sont inférieures à 24 et supérieur ou egales a 0
     * @return vrai si l'heure est existante (0<=heure<24, etc.), faux dans le cas contraire
     */
    public boolean verifierHeures () {
    	
	String heureDeFin = heureFinH.getText ();//On récupere l'heure de fin
	String heureDeDebut = heureDebutH.getText ();//on recupere l'heure de debut
		
	if ( (Integer.parseInt (heureDeFin) >=0 ) && ( (Integer.parseInt (heureDeFin) >= 0 ) && ( (Integer.parseInt (heureDeDebut) <24) && ( (Integer.parseInt (heureDeFin) <24))))) {
	    //Si l'heure de fin et l'heure de debut sont compris entre 0 et 23 compris
			
	    //on retourne vrai, le test est vérifie
	    return true;
	} else {
	    //Sinon
		
	    //On affiche le message d'erreur correspondant
	    JOptionPane.showMessageDialog (panelGlobal,
					   "L'heure saisie doit etre comprise entre 0 et 23.",
					   "Error : mauvaises heures",
					   JOptionPane.ERROR_MESSAGE);
	    //et on retourne faux, le test n'est pas verifie
	    return false;				
	}
    	
    }// ----------------------------------------------------------- verifierHeures ()
    
    
    
    //========================= Methodes de suppression ==========================//
    /**
     * Methode qui permet de supprimer toutes les activites presentes dans l'ancien
     * On demande tout de meme a l'utilisateur de reflechir a deux avant d'excuter cette commande
     */
    public void supprimerToutesActivites () {
		
	if (JOptionPane.showConfirmDialog (panelGlobal,
					   "Voulez vous vraiment supprimer toutes les activites ?", "Attention ! les activites vont etre supprimees", 
					   JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {	
	    //Si l'utilisateur répond "oui" lorsqu'on lui demande s'il veut supprimer toutes les activites
		
	    //On appel la méthode supprimerTout du model de l'ancien
	    model.supprimerTout ();
			
	    //On affiche un message stipulant que les activites ont bien ete supprimees
	    JOptionPane.showMessageDialog (panelGlobal,
					   "Toutes les activites ont bien ete supprimees", "Suppression des activites", 
					   JOptionPane.INFORMATION_MESSAGE);
			
	    System.out.println ("Toutes les activites sont supprimees");
	
	}
    }// ----------------------------------------------------------- supprimerToutesActivites ()


    /**
     * Methode qui fait le lien entre la suppression dans le model et l'interface.
     * On y appelle a methode du modele qui permet de supprimer une activite en fonction de son id.
     * @param id l'identifiant de l'activite a supprimer
     */
    public void supprimerActivite (int id) {
    	
    	if (JOptionPane.showConfirmDialog (panelGlobal,
					   "Voulez vous vraiment supprimer cette activite ?", "Attention ! l'activite va etre supprimee", 
					   JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
	    //Si l'utilisateur a cliqué sur "oui" apres lui avoir demander s'il voulait continuer
	    //On supprimer reellement l'activite
	    model.supprimerActivite (id);
	    	
	    this.sauvegarde ();//et on sauvegarde
    	}
    }// ----------------------------------------------------------- supprimerActivite ( id : int)
    
    
    //=============================== Modification d'une activite =========================================//
    /**
     * Methode graphique qui permet de reafficher un ecran quand on clique sur Editer.
     * On y affiche la même chose que lorsqu'on ajoute une activite mais les champs sont deja préremplis par les parametres de l'activite
     * Selon le type d'activite, on rappelle les panel différents 
     * @param id l'identifiant de l'activite a modifier
     */
    public void modifierActivitePanel (int id) {
    	
    	idCourant = id;//l'id courant prend la valeur de l'identifiant de l'activite a modifier
    	
    	if (model.chercheActivite (id).getType ().equals ("Autre")) {
	    //Si le type de l'activite est "Autre"
	    //On appelle la methode base de l'ajout d'une activites
	    this.initNouvelleActiviteDefaut ();
    	}
    	if (model.chercheActivite (id).getType ().equals ("RDV")) {
	    //Si le type de l'activite est "RDV"
	    //On appelle la methode d'ajout d'un RDV
	    this.initNouvelleActiviteRDV ();
	    Rdv rdv = (Rdv)model.chercheActivite (id);
	    initiateurText.setText (rdv.getInitiateur ());//et on préremplit le champs de l'initiateur
    	}
    	if (model.chercheActivite (id).getType ().equals ("Reunion")) {
	    //Si le type de l'activite est "Reunion"
	    //On appelle la methode d'ajout d'un Reunion
	    this.initNouvelleActiviteReunion ();
	    Reunion reunion = (Reunion)model.chercheActivite (id);
	    listePersonneText.setText (reunion.getListePersonne ());//et on préremplit le champs de la listePersonne
    	}
    	if (model.chercheActivite (id).getType ().equals ("Cours")) {
	    //Si le type de l'activite est "Cours"
	    //On appelle la methode d'ajout d'un Cours
	    this.initNouvelleActiviteCours ();
	    Cours cours = (Cours)model.chercheActivite (id);
	    //et on préremplit les champs du professeur et de la matiere
	    professeurText.setText (cours.getProfesseur ());
	    matiereText.setText (cours.getMatiere ());
    	}
    	
    	enregistrerActivite.setActionCommand ("EnregistrerModifier");//on met un actionCommand sur le bouton enregistrer (le différencier de celui pour ajouter une activite)    	
    	
    	retourActivite.setActionCommand ("retourModifierAJour");//on met un actionCommand sur le bouton retour (le differencier vu qu'il faut retourner à l'ecran du jour)
    	
    	//On préremplit les champs par defaut
    	motifText.setText (model.chercheActivite (id).getMotif ());
    	heureDebutH.setText (String.valueOf (model.chercheActivite (id).getHeureDebut ()));
    	heureDebutM.setText (String.valueOf (model.chercheActivite (id).getMinuteDebut ()));
    	heureFinH.setText (String.valueOf (model.chercheActivite (id).getHeureFin ()));
    	heureFinM.setText (String.valueOf (model.chercheActivite (id).getMinuteFin ()));
    	dateJourText.setText (String.valueOf (model.chercheActivite (id).getJour ()));
    	dateMoisText.setText (String.valueOf (model.chercheActivite (id).getMois ()));
    	dateAnneeText.setText (String.valueOf (model.chercheActivite (id).getAnnee ()));
    	lieuText.setText (model.chercheActivite (id).getLieu ());

    }// ----------------------------------------------------------- modifierActivitePanel ( id : int)
    
    /**
     * Methode qui verifie les champs, la validite de la date etc. pour la modification d'une activite
     * Si on peut modifier l'activite, on met a jour les parametre de l'activite a modifier. Sinon on revient au panel de la modification
     * @return vrai si l'activite a bien ete modifiee, faux dans le cas contraire
     */
    public boolean modifierActivite () {
    	
    	if (this.verifierChamps ()) {
	    //Si les champs obligatoire ont ete remplis
    		
	    if (this.verifierInt ()) {
    		//Si la date et les heures sont des nombres entier
    			
		if (this.verifierDate () && this.verifierHeures () && this.verifierMinutes ()) {
		    //Si la Date, les heures et les minutes sont valides (ex : 0<=heure<24)
		    		
		    if (this.verifierHeureDebutAvantFin ()) {
			//Si l'heure de debut est bien avant l'heure de fin
		    			
			if (model.modifierActivite (new Activite (idCourant , motifText.getText (), Integer.parseInt (heureDebutH.getText ()),
								  Integer.parseInt (heureFinH.getText ()), Integer.parseInt (heureDebutM.getText ()), 
								  Integer.parseInt (heureFinM.getText ()), Integer.parseInt (dateJourText.getText ()),
								  Integer.parseInt (dateMoisText.getText ()), Integer.parseInt (dateAnneeText.getText ()),
								  lieuText.getText (),"Autre"))) {
			    //Si on peut modifier une nouvelle activite qui correspond a la modification faite (on verifie si elle chevauche ou pas)
		    				
			    //Si tout se passe bien, on met ajour les parametres de l'activite en fonction de ce qui a ete saisie dans la modification
			    model.chercheActivite (idCourant).setMotif (motifText.getText ());
			    model.chercheActivite (idCourant).setHeureDebut (Integer.parseInt (heureDebutH.getText ()));
			    model.chercheActivite (idCourant).setMinuteDebut (Integer.parseInt (heureDebutM.getText ()));
			    model.chercheActivite (idCourant).setHeureFin (Integer.parseInt (heureFinH.getText ()));
			    model.chercheActivite (idCourant).setMinuteFin (Integer.parseInt (heureFinM.getText ()));
			    model.chercheActivite (idCourant).setJour (Integer.parseInt (dateJourText.getText ()));
			    model.chercheActivite (idCourant).setMois (Integer.parseInt (dateMoisText.getText ()));
			    model.chercheActivite (idCourant).setAnnee (Integer.parseInt (dateAnneeText.getText ()));
			    model.chercheActivite (idCourant).setLieu (lieuText.getText ());
					    	
			    //Selon le type de l'actitive, on modifie aussi l'initiateur, la liste de personne, la matiere et le professeur
					    	
			    if (model.chercheActivite (idCourant).getType ().equals ("RDV")) {
				Rdv rdv = (Rdv)model.chercheActivite (idCourant);
				rdv.setInitiateur (initiateurText.getText ());
			    }
			    if (model.chercheActivite (idCourant).getType ().equals ("Reunion")) {
				Reunion reunion = (Reunion)model.chercheActivite (idCourant);
				reunion.setListePersonne (listePersonneText.getText ());
			    }
			    if (model.chercheActivite (idCourant).getType ().equals ("Cours")) {
				Cours cours = (Cours)model.chercheActivite (idCourant);
				cours.setMatiere (matiereText.getText ());
				cours.setProfesseur (professeurText.getText ());
			    }
					    	
			    //On affiche un message pour informer l'utilisateur que son activite a bien ete modifiee
			    JOptionPane.showMessageDialog (panelGlobal,
							   "L'activite a bien ete modifiee",
							   "Activite modifiee !",
							   JOptionPane.INFORMATION_MESSAGE);
					    	
			    return true;//On retourne vrai, l'activite a bien ete modifiee
					    	
					    	
			} else {
			    //Sinon si on ne peut pas modifier l'activite (chevauchement avec une autre)
		    			
		    				
			    JOptionPane.showMessageDialog (panelGlobal,
							   "Une activite existe deja dans ces heures la !\nVeuillez changer votre date et/ou les heures.",
							   "Erreur : Chevauchement d'activite !",
							   JOptionPane.ERROR_MESSAGE);
		    				
			    return false;//On retourne faux, l'activite n'a pas ete modifiee
			}
		    } else {
			//Sinon si on l'heure de fin est inferieur a l'heure de debut, il y un pbm, l'activite n'a pas a etre modifiee
		    		
			JOptionPane.showMessageDialog (panelGlobal,
						       "L'heure du début doit etre inferieure a l'heure de fin !\nVeuillez vérifier les heures donnees",
						       "Erreur : Incohérence des heures !",
						       JOptionPane.ERROR_MESSAGE);
		    			
			return false;//On retourne faux, l'activite n'a pas ete modifiee
		    }
		} else
		    //Sinon si la date et les heures ne sont pas valides
		    	
		    return false;//On retourne faux, l'activite n'a pas ete modifiee
	    } else {
    		//Sinon si la date et les heures ne sont pas des nombre entier de 2 chiffres (caracteres autres, etc.)
    		
	
		JOptionPane.showMessageDialog (panelGlobal,
					       "La date et les heures doivent etre des nombres entiers",
					       "Error : Nombres entiers demandes !",
					       JOptionPane.ERROR_MESSAGE);
		return false;//On retourne faux, l'activite n'a pas ete modifiee
	    }
    	} else {
	    //Sinon si un champs obligatoire n'a pas ete remplis
    	
    		
	    JOptionPane.showMessageDialog (panelGlobal,
					   "Certains champs de texte ne sont pas remplis\nLe motif, la date et les heures sont obligatoires",
					   "Error : champs manquants",
					   JOptionPane.ERROR_MESSAGE);
    		
	    return false;//On retourne faux, l'activite n'a pas ete modifiee
    	}
    }// ----------------------------------------------------------- modifierActivite ()
    
   
   
    //==================================== Import/Export de liste d'activites ==============================//
    /**
     * Methode qui permet de sauvegarder une liste d'activites en l'enregistrant dans un fichier.obj
     * à l'endroit ou l'utilisateur veut.
     * Elle est appelee lorsque l'utilisateur clique sur le bouton correspondant dans le menu déroulant principal
     */
    public void sauvegarderListeSous () {
      	
        if (chooser == null) {
	    //Si chooser est null
	    //on instancie chooser avec le startPath du repertoire courant 
            chooser = new JFileChooser ("./");
        }
        
        //On ajoute une fileFilter sur le chooser pour ne voir que les fichier .obj
        FileFilter objetFilter = new FileNameExtensionFilter ("Fichiers objets : *.obj", "obj");
        chooser.setFileFilter (objetFilter);
        chooser.setAcceptAllFileFilterUsed (false);
        
        //i prend la valeur de ce qu'on aura choisi dans la fenetre de dialogue
        int i = chooser.showSaveDialog (panelGlobal);
        
        if (i == JFileChooser.APPROVE_OPTION) {
	    //Si l'utilisateur a choisis un fichier (n'as pas fait cancel, etc.)
        	
	    //selectedFile prend la valeur du nom que l'utilisateur a choisit
	    selectedFile = chooser.getSelectedFile ();
        	
	    String file = selectedFile.toString ();
			
	    //On cree un patern pour savoir ensuite si un .obj a ete ajoute par l'utilisateur ou non
	    Pattern p = Pattern.compile (".obj$");
	    Matcher m = p.matcher (file);
			
	    if (!m.find ())
		//Si l'utilisateur n'a pas ajouté .obj a la fin de son fichier
		//alors on ajoute .obj a la fin du fichier
		file+=".obj";
        	
	    try{ 
        		
		FileOutputStream lu = new FileOutputStream (file);	
		ObjectOutputStream s = new ObjectOutputStream (lu);
		s.writeObject (model);//on ecrit le model dans le nouveau fichier
		s.flush ();
		System.out.println ("Ok, sauvegarde dans le nouveau .obj");
		lu.close (); 
        	   
	    } catch (IOException e) {
		System.out.println ("Probleme d'ecriture sur" + selectedFile+" lors de la sauvegarde dans un nouveau .obj");
	    }
 
        }
    }// ----------------------------------------------------------- sauvegarderListeSous ()
    
    /**
     * Methode qui permet d'importer une liste d'activites en ouvrant un fichier.obj
     * Les activites courantes sont remplacees par celles du nouveau fichier et tout est enregistre dans le fichier par defaut
     * Elle est appelee lorsque l'utilisateur clique sur le bouton correspondant dans le menu déroulant principal
     */
    public void importerListe () {
    	
    	if (JOptionPane.showConfirmDialog (panelGlobal,
					   "Les activites courantes seront remplacees!\nVoulez vous continuer ?", "Remplacement des activites", 
					   JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE) == JOptionPane.YES_OPTION) {
	    //Si l'utilisateur choisit "oui" lorsqu'on lui demande s'il veut continuer
	    //on initialise le chooser au répertoir courant
	    chooser = new JFileChooser ("./");
	        
	    //Par defaut, les fichiers vu seront les fichiers avec l'extension .obj
	    FileFilter objetFilter = new FileNameExtensionFilter ("Fichiers objets : *.obj", "obj");
	    chooser.setFileFilter (objetFilter);
	    chooser.setAcceptAllFileFilterUsed (false);

	    //i prend la valeur de ce qu'on aura choisi dans la fenetre de dialogue
	    int i = chooser.showOpenDialog (panelGlobal);
	        
	    if (i == JFileChooser.APPROVE_OPTION) {
		//Si l'utilisateur a choisis un fichier (n'as pas fait cancel, etc.)
		//selectedFile prend la valeur du fichier choisis par l'utilisateur
		selectedFile = chooser.getSelectedFile ();
		    	
		try {
		    FileInputStream f = new FileInputStream (selectedFile);
		    ObjectInputStream s = new ObjectInputStream (f);
		    model = (AncienModel) s.readObject ();//on modifie le model avec les nouvelles activites
		    this.sauvegarde ();//on sauvegarde
		} catch (IOException e) {
		    System.out.println ("Erreur d'entree/sortie lors de l'import");
		    JOptionPane.showMessageDialog (panelGlobal,
						   "Le fichier importé n'est pas du bon format (.obj)\nou le fichier ne comprend pas d'activites valides.\n\n" +
						   "Veuillez vérifier le contenu et le format du fichier", "Erreur : mauvais format", 
						   JOptionPane.ERROR_MESSAGE);
		} catch (ClassNotFoundException e) {
		    e.getMessage ();
		}
	    }
    	}
    }// ----------------------------------------------------------- importerListe ()
    
    
    
    
    //============================== Sauvegarder et recuperation de liste ==============================//
    
    /**
     * Methode qui permet de sauvegarder les activites dans un fichier listeActivites.obj
     */
    public void sauvegarde () {
	try {FileOutputStream f = new FileOutputStream ("listeActivites.obj");
	    ObjectOutputStream s = new ObjectOutputStream (f);
	    s.writeObject (model);
	    s.flush ();
	    System.out.println ("Ok, sauvegarde dans listeActivites.obj");
	} catch (IOException e) {
	    System.out.println ("Probleme lors de la sauvegarde" + e.getMessage ());
	}
    }// ----------------------------------------------------------- sauvegarde ()
	
    /**
     *restaure les activites a partir du fichier listeActivites.obj
     */
    public void restaure () {
	System.out.println ("restaure");
	try {FileInputStream f = new FileInputStream ("listeActivites.obj");
	    ObjectInputStream s = new ObjectInputStream (f);
	    model = (AncienModel) s.readObject ();
	} catch (IOException e) {
	    System.out.println ("Nouvel liste d'activites");
	} catch (ClassNotFoundException e) {
	    e.getMessage ();
	}
    }// ----------------------------------------------------------- restaure ()
	
	
	
    //============================ Getters ============================================
	
    /**
     * Methode qui permet de recuperer le nom du jour en fonction du numero de jour dans le mois
     * @param numeroDuJour le numero du jour dans le mois
     * @return le nom du jour correspondant au numero du jour dans le mois
     */
    public String getNomDuJour (int numeroDuJour) {
		
	//on créé un nouveau calendar qui prend en parametre l'annee courante, le mois courant ET le parametre de cette methode : numeroDuJour
	GregorianCalendar c = new GregorianCalendar (anneeCourante,moisCourant,numeroDuJour);
	int jourSemaine = c.get (GregorianCalendar.DAY_OF_WEEK);//on instancie un entier qui prend la valeur du numero du jour correspondant dans la semaine (entre 1 et 7, 1 corresdant à Sunday)
	    
	//Le calendrier anglais commence à dimanche, et continue jusqu'a samedi, il faut donc le placer à la fin pour le calendrier francais
	if (jourSemaine == 1)
	    jourSemaine = 8;
		
	jourSemaine -= 2;//on enleve 2 a ce jour (decale de 1 par rapport a la condition precedente, et de 1 pour que le premier jour soit le jour n°0)
	    
	//on créé un nouveau tableau avec la liste des jour en français
	String[] listeJour = new String[7];
	listeJour[0] = "Lundi";
	listeJour[1] = "Mardi";
	listeJour[2] = "Mercredi";
	listeJour[3] = "Jeudi";
	listeJour[4] = "Vendredi";
	listeJour[5] = "Samedi";
	listeJour[6] = "Dimanche";
	    
	return listeJour[jourSemaine];//on retourne le String du nom du jour correspondant au jour de la semaine
	
    }// ----------------------------------------------------------- getNomDuJour ( numeroDuJour : int)


    /**
     * Accesseur du nom d'un mois en fonction de l'index (ex: decembre : 12)
     * @param indexMois l'index du mois dans l'annee
     * @return le mois correspondant au numero du mois en parametre
     */
    public String getMoisDeIndex (int indexMois) {
	return listeMois[indexMois -1];
    }// ----------------------------------------------------------- getMoisDeIndex (indexMois : int)


    /**
     * Accesseur de la taille du menu popup du bouton options du calendrier (il permettra de calculer précisemment la position du pop up)
     * @return la taille du menu popup
     */
    public int getPopUpMenuHeight () {
    	return popUpMenu.getHeight ();
    }// ----------------------------------------------------------- getPopUpMenuHeight ()
    
    /**
     * Accesseur de la taille du menu popUp du bouton "ajouter activite" lorsqu'on est sur un jour spécifique
     * (il permettra de calculer précisemment la position du pop up)
     * @return la taille de menu popup
     */
    public int getPopUpMenuActiviteHeight () {
    	return popUpMenuActivite.getHeight ();
    }// ----------------------------------------------------------- getPopUpMenuActiviteHeight ()
    
    /** 
     * renvoit le panel de l'application
     * @return le panel principal de l'application
     */
    public JPanel getPanel () {
    	return panelGlobal;
    } // ----------------------------------------------------------- getPanel ()
    
    /**
     * Renvoi l'annee courante de l'ancien
     * @return l'annee courante de l'ancien
     */
    public int getAnneeCourante () {
    	return anneeCourante;
    }// ----------------------------------------------------------- getAnneeCourante ()
    
    /**
     * Renvoi le mois courant de l'ancien
     * @return le mois courant de l'ancien
     */
    public int getMoisCourant () {
    	return moisCourant;
    }// ----------------------------------------------------------- getMoisCourant ()
    
    /**
     * Renvoi le jour courant de l'ancien
     * @return le jour courant de l'ancien
     */
    public int getJourCourant () {
    	return jourCourant;
    }// ----------------------------------------------------------- getJourCourant ()
    
    
    
    //================================= Setters ===================================//
    /**
     * Remplace l'annee Courante de l'ancien par l'annee courante en paramètre
     * @param anneeCourante l'annee courante qui remplace l'annee courante de l'ancien
     */
    public void setAnneeCourante (int anneeCourante) {
    	this.anneeCourante = anneeCourante;
    }// ----------------------------------------------------------- setAnneeCourante (anneeCourante : int)
    
    /**
     * Remplace le jour courant de l'ancien par le jour courant en parametre
     * @param jourCourant le jour Courant qui remplace le jour courant de l'ancien
     */
    public void setJour (int jourCourant) {
    	this.jourCourant = jourCourant;
    }// ----------------------------------------------------------- setJour (jourCourant : int)
    
    /**
     * 
     */
    public boolean isPasseParMenuPopUpActivite () {
    	return estPasseParMenuPopUpActivite;
    }
    

} // ------------------------------------------------------------- Class HWView
